ஜாவாஸ்கிரிப்ட் அசிங்க் இட்டரேட்டர் ஹெல்பர்ஸ்: ஸ்ட்ரீம் செயலாக்கம் மற்றும் மாற்றத்தில் புரட்சி

வலை மேம்பாடு மற்றும் ஒத்திசைவற்ற நிரலாக்கத்தின் எப்போதும் மாறிவரும் உலகில், தரவு ஸ்ட்ரீம்களை திறமையாக கையாள்வது மிக முக்கியம். நீங்கள் பயனர் உள்ளீடுகளைச் செயலாக்கினாலும், நெட்வொர்க் பதில்களை நிர்வகித்தாலும், அல்லது பெரிய தரவுத்தொகுப்புகளை மாற்றினாலும், ஒத்திசைவற்ற தரவு ஓட்டங்களை தெளிவான மற்றும் நிர்வகிக்கக்கூடிய வழியில் கையாளும் திறன், பயன்பாட்டின் செயல்திறன் மற்றும் டெவலப்பரின் உற்பத்தித்திறனை கணிசமாக பாதிக்கும். ஜாவாஸ்கிரிப்ட்டின் அசிங்க் இட்டரேட்டர்கள் அறிமுகம், அசிங்க் இட்டரேட்டர் ஹெல்பர்ஸ் முன்மொழிவுடன் (இப்போது ECMAScript 2023-இன் ஒரு பகுதி) உறுதிப்படுத்தப்பட்டு, இந்த விஷயத்தில் ஒரு குறிப்பிடத்தக்க முன்னேற்றத்தைக் குறிக்கிறது. இந்த கட்டுரை அசிங்க் இட்டரேட்டர் ஹெல்பர்ஸின் ஆற்றலை ஆராய்கிறது, ஸ்ட்ரீம் செயலாக்கம் மற்றும் மேம்பட்ட தரவு மாற்றங்களுக்கான அவற்றின் திறன்கள் குறித்த உலகளாவிய கண்ணோட்டத்தை வழங்குகிறது.

அடிப்படை: அசிங்க் இட்டரேட்டர்களைப் புரிந்துகொள்ளுதல்

ஹெல்பர்ஸைப் பற்றி தெரிந்துகொள்வதற்கு முன், அசிங்க் இட்டரேட்டர்களின் முக்கிய கருத்தைப் புரிந்துகொள்வது அவசியம். ஒரு அசிங்க் இட்டரேட்டர் என்பது [Symbol.asyncIterator]() முறையை செயல்படுத்தும் ஒரு பொருளாகும். இந்த முறை ஒரு அசிங்க் இட்டரேட்டர் பொருளைத் திருப்பித் தரும், அது ஒரு next() முறையைக் கொண்டுள்ளது. next() முறை ஒரு Promise-ஐத் திருப்பித் தரும், அது இரண்டு பண்புகளுடன் ஒரு பொருளாகத் தீர்க்கப்படும்: value (வரிசையில் அடுத்த உருப்படி) மற்றும் done (சுழற்சி முடிந்ததா என்பதைக் குறிக்கும் ஒரு பூலியன்).

இந்த ஒத்திசைவற்ற தன்மை, தொலைநிலை API-இலிருந்து தரவைப் பெறுதல், பிரதான திரியைத் தடுக்காமல் கோப்பு முறைமையிலிருந்து படித்தல், அல்லது WebSocket இணைப்பிலிருந்து தரவுத் துண்டுகளைச் செயலாக்குதல் போன்ற நேரமெடுக்கும் செயல்பாடுகளைக் கையாள்வதில் முக்கியமானது. பாரம்பரியமாக, இந்த ஒத்திசைவற்ற வரிசைகளை நிர்வகிப்பது சிக்கலான கால்பேக் வடிவங்கள் அல்லது பிராமிஸ் சங்கிலிகளை உள்ளடக்கியிருக்கலாம். அசிங்க் இட்டரேட்டர்கள், for await...of வளையத்துடன் இணைந்து, ஒத்திசைவற்ற சுழற்சிக்கு மிகவும் ஒத்திசைவான தோற்றமுடைய தொடரியலை வழங்குகின்றன.

ஹெல்பர்ஸின் தேவை: ஒத்திசைவற்ற செயல்பாடுகளை நெறிப்படுத்துதல்

அசிங்க் இட்டரேட்டர்கள் ஒரு சக்திவாய்ந்த சுருக்கத்தை வழங்கினாலும், பொதுவான ஸ்ட்ரீம் செயலாக்கம் மற்றும் மாற்றப் பணிகளுக்கு பெரும்பாலும் பாய்லர்பிளேட் குறியீடு தேவைப்படுகிறது. ஒரு ஒத்திசைவற்ற தரவு ஸ்ட்ரீமை வடிகட்ட, மேப் செய்ய அல்லது குறைக்க வேண்டும் என்று கற்பனை செய்து பாருங்கள். பிரத்யேக ஹெல்பர்கள் இல்லாமல், நீங்கள் பொதுவாக இந்த செயல்பாடுகளை கைமுறையாக செயல்படுத்துவீர்கள், அசிங்க் இட்டரேட்டர் மூலம் சுழன்று புதிய வரிசைகளை உருவாக்குவீர்கள், இது விரிவானதாகவும் பிழைக்கு ஆளாகக்கூடியதாகவும் இருக்கும்.

அசிங்க் இட்டரேட்டர் ஹெல்பர்ஸ் முன்மொழிவு, அசிங்க் இட்டரேட்டர் நெறிமுறையில் நேரடியாகப் பயன்பாட்டு முறைகளின் தொகுப்பை வழங்குவதன் மூலம் இந்த சிக்கலைத் தீர்க்கிறது. இந்த ஹெல்பர்கள் செயல்பாட்டு நிரலாக்கக் கருத்துக்கள் மற்றும் எதிர்வினை நிரலாக்க நூலகங்களால் ஈர்க்கப்பட்டு, ஒத்திசைவற்ற தரவு ஸ்ட்ரீம்களுக்கு ஒரு விளக்கமளிக்கும் மற்றும் இணைக்கக்கூடிய அணுகுமுறையைக் கொண்டு வருகின்றன. இந்த தரப்படுத்தல் உலகெங்கிலும் உள்ள டெவலப்பர்கள் சீரான மற்றும் பராமரிக்கக்கூடிய ஒத்திசைவற்ற குறியீட்டை எழுதுவதை எளிதாக்குகிறது.

அசிங்க் இட்டரேட்டர் ஹெல்பர்ஸை அறிமுகப்படுத்துதல்

அசிங்க் இட்டரேட்டர் ஹெல்பர்ஸ், எந்தவொரு அசிங்க் இட்டரேபிள் பொருளின் திறன்களையும் மேம்படுத்தும் பல முக்கிய முறைகளை அறிமுகப்படுத்துகிறது. இந்த முறைகளை ஒன்றாக இணைக்க முடியும், இது சிக்கலான தரவு பைப்லைன்களை குறிப்பிடத்தக்க தெளிவுடன் உருவாக்க அனுமதிக்கிறது.

1. .map(): ஒவ்வொரு உருப்படியையும் மாற்றுதல்

.map() ஹெல்பர் ஒரு அசிங்க் இட்டரேட்டர் மூலம் வழங்கப்படும் ஒவ்வொரு உருப்படியையும் மாற்றப் பயன்படுகிறது. இது தற்போதைய உருப்படியைப் பெறும் ஒரு கால்பேக் செயல்பாட்டை எடுத்து, மாற்றப்பட்ட உருப்படியை திருப்பித் தர வேண்டும். அசல் அசிங்க் இட்டரேட்டர் மாறாமல் இருக்கும்; .map() மாற்றப்பட்ட மதிப்புகளை வழங்கும் ஒரு புதிய அசிங்க் இட்டரேட்டரைத் திருப்பித் தரும்.

பயன்பாட்டு எடுத்துக்காட்டு (உலகளாவிய மின்வணிகம்):

ஒரு சர்வதேச சந்தை API-இலிருந்து தயாரிப்புத் தரவைப் பெறும் ஒரு அசிங்க் இட்டரேட்டரைக் கவனியுங்கள். ஒவ்வொரு உருப்படியும் ஒரு சிக்கலான தயாரிப்புப் பொருளாக இருக்கலாம். நீங்கள் இந்த பொருட்களை, ஒரு குறிப்பிட்ட நாணயத்தில் தயாரிப்புப் பெயர் மற்றும் விலையை மட்டும் கொண்ட ஒரு எளிய வடிவத்திற்கு மாற்ற விரும்பலாம், அல்லது எடைகளை கிலோகிராம் போன்ற ஒரு நிலையான அலகாக மாற்ற விரும்பலாம்.

            async function* getProductStream(apiEndpoint) {
  // Simulate fetching product data asynchronously
  const response = await fetch(apiEndpoint);
  const products = await response.json();
  for (const product of products) {
    yield product;
  }
}

async function transformProductPrices(apiEndpoint, targetCurrency) {
  const productStream = getProductStream(apiEndpoint);

  // Example: Convert prices from USD to EUR using an exchange rate
  const exchangeRate = 0.92; // Example rate, would typically be fetched

  const transformedStream = productStream.map(product => {
    const priceInTargetCurrency = (product.priceUSD * exchangeRate).toFixed(2);
    return {
      name: product.name,
      price: `${priceInTargetCurrency} EUR`
    };
  });

  for await (const transformedProduct of transformedStream) {
    console.log(`Transformed: ${transformedProduct.name} - ${transformedProduct.price}`);
  }
}

// Assuming a mock API response for products
// transformProductPrices('https://api.globalmarketplace.com/products', 'EUR');

            

              
                Copy
              
            
          

முக்கிய குறிப்பு: .map() ஒத்திசைவற்ற தரவு ஸ்ட்ரீம்களின் ஒன்றுக்கு-ஒன்று மாற்றங்களை அனுமதிக்கிறது, இது நெகிழ்வான தரவு வடிவமைத்தல் மற்றும் செறிவூட்டலை செயல்படுத்துகிறது.

2. .filter(): தொடர்புடைய உருப்படிகளைத் தேர்ந்தெடுத்தல்

.filter() ஹெல்பர், ஒரு குறிப்பிட்ட நிபந்தனையை பூர்த்தி செய்யும் உருப்படிகளை மட்டும் வழங்கும் ஒரு புதிய அசிங்க் இட்டரேட்டரை உருவாக்க உங்களை அனுமதிக்கிறது. இது ஒரு உருப்படியைப் பெறும் ஒரு கால்பேக் செயல்பாட்டை எடுத்து, உருப்படியை வைத்திருக்க true அல்லது நிராகரிக்க false என்று திருப்பித் தர வேண்டும்.

பயன்பாட்டு எடுத்துக்காட்டு (சர்வதேச செய்தி ஓடை):

பல்வேறு உலகளாவிய மூலங்களிலிருந்து வரும் செய்தி கட்டுரைகளின் ஒரு அசிங்க் ஸ்ட்ரீமை செயலாக்குவதை கற்பனை செய்து பாருங்கள். ஒரு குறிப்பிட்ட நாடு அல்லது ஆர்வமுள்ள பகுதியைக் குறிப்பிடாத கட்டுரைகளை நீங்கள் வடிகட்ட விரும்பலாம், அல்லது ஒரு குறிப்பிட்ட தேதிக்குப் பிறகு வெளியிடப்பட்ட கட்டுரைகளை மட்டும் சேர்க்க விரும்பலாம்.

            async function* getNewsFeed(sourceUrls) {
  for (const url of sourceUrls) {
    // Simulate fetching news from a remote source
    const response = await fetch(url);
    const articles = await response.json();
    for (const article of articles) {
      yield article;
    }
  }
}

async function filterArticlesByCountry(sourceUrls, targetCountry) {
  const newsStream = getNewsFeed(sourceUrls);

  const filteredStream = newsStream.filter(article => {
    // Assuming each article has a 'countries' array property
    return article.countries && article.countries.includes(targetCountry);
  });

  console.log(`
--- Articles related to ${targetCountry} ---`);
  for await (const article of filteredStream) {
    console.log(`- ${article.title} (Source: ${article.source})`);
  }
}

// const newsSources = ['https://api.globalnews.com/tech', 'https://api.worldaffairs.org/politics'];
// filterArticlesByCountry(newsSources, 'Japan');

            

              
                Copy
              
            
          

முக்கிய குறிப்பு: .filter() ஒத்திசைவற்ற ஸ்ட்ரீம்களிலிருந்து குறிப்பிட்ட தரவுப் புள்ளிகளைத் தேர்ந்தெடுக்க ஒரு விளக்கமளிக்கும் வழியை வழங்குகிறது, இது கவனம் செலுத்திய தரவு செயலாக்கத்திற்கு முக்கியமானது.

3. .take(): ஸ்ட்ரீமின் நீளத்தைக் கட்டுப்படுத்துதல்

.take() ஹெல்பர் ஒரு அசிங்க் இட்டரேட்டர் மூலம் வழங்கப்படும் உருப்படிகளின் எண்ணிக்கையைக் கட்டுப்படுத்த உங்களை அனுமதிக்கிறது. ஒரு முடிவில்லாத அல்லது மிக நீண்ட ஸ்ட்ரீமிலிருந்து முதல் N உருப்படிகள் மட்டுமே உங்களுக்குத் தேவைப்படும்போது இது மிகவும் பயனுள்ளதாக இருக்கும்.

பயன்பாட்டு எடுத்துக்காட்டு (பயனர் செயல்பாட்டுப் பதிவு):

பயனர் செயல்பாட்டை பகுப்பாய்வு செய்யும்போது, ஒரு அமர்வில் முதல் 100 நிகழ்வுகளை மட்டுமே செயலாக்க வேண்டியிருக்கலாம், அல்லது ஒரு குறிப்பிட்ட பகுதியிலிருந்து முதல் 10 உள்நுழைவு முயற்சிகளை மட்டுமே செயலாக்க வேண்டியிருக்கலாம்.

            async function* getUserActivityStream(userId) {
  // Simulate generating user activity events
  let eventCount = 0;
  while (eventCount < 500) { // Simulate a large stream
    await new Promise(resolve => setTimeout(resolve, 10)); // Simulate async delay
    yield { event: 'click', timestamp: Date.now(), count: eventCount };
    eventCount++;
  }
}

async function processFirstTenEvents(userId) {
  const activityStream = getUserActivityStream(userId);

  const limitedStream = activityStream.take(10);

  console.log(`
--- Processing first 10 user events ---`);
  let processedCount = 0;
  for await (const event of limitedStream) {
    console.log(`Processed event ${processedCount + 1}: ${event.event} at ${event.timestamp}`);
    processedCount++;
  }
  console.log(`Total events processed: ${processedCount}`);
}

// processFirstTenEvents('user123');

            

              
                Copy
              
            
          

முக்கிய குறிப்பு: .take() வள நுகர்வைக் நிர்வகிப்பதற்கும், பெரிய ஒத்திசைவற்ற வரிசைகளில் ஆரம்ப தரவுப் புள்ளிகளில் கவனம் செலுத்துவதற்கும் அவசியம்.

4. .drop(): ஆரம்ப உருப்படிகளைத் தவிர்த்தல்

இதற்கு மாறாக, .drop() ஒரு அசிங்க் இட்டரேட்டரின் தொடக்கத்திலிருந்து குறிப்பிட்ட எண்ணிக்கையிலான உருப்படிகளைத் தவிர்க்க உங்களை அனுமதிக்கிறது. நீங்கள் செயலாக்க விரும்பும் உண்மையான தரவை அடைவதற்கு முன்பு ஆரம்ப அமைப்பு அல்லது மெட்டாடேட்டாவைத் தவிர்ப்பதற்கு இது பயனுள்ளதாக இருக்கும்.

பயன்பாட்டு எடுத்துக்காட்டு (நிதி தரவு டிக்கர்):

ஒரு நிகழ்நேர நிதி தரவு ஸ்ட்ரீமுக்கு குழுசேரும்போது, ஆரம்ப செய்திகள் இணைப்பு ஒப்புதல்கள் அல்லது மெட்டாடேட்டாவாக இருக்கலாம். நீங்கள் இவற்றைத் தவிர்த்து, உண்மையான விலை புதுப்பிப்புகள் தொடங்கும் போது மட்டுமே செயலாக்கத் தொடங்க விரும்பலாம்.

            async function* getFinancialTickerStream(symbol) {
  // Simulate initial handshake/metadata
  yield { type: 'connection_ack', timestamp: Date.now() };
  yield { type: 'metadata', exchange: 'NYSE', timestamp: Date.now() };

  // Simulate actual price updates
  let price = 100;
  for (let i = 0; i < 20; i++) {
    await new Promise(resolve => setTimeout(resolve, 50));
    price += (Math.random() - 0.5) * 2;
    yield { type: 'price_update', symbol: symbol, price: price.toFixed(2), timestamp: Date.now() };
  }
}

async function processTickerUpdates(symbol) {
  const tickerStream = getFinancialTickerStream(symbol);

  const dataStream = tickerStream.drop(2); // Skip the first two non-data messages

  console.log(`
--- Processing ticker updates for ${symbol} ---`);
  for await (const update of dataStream) {
    if (update.type === 'price_update') {
      console.log(`${update.symbol}: $${update.price} at ${new Date(update.timestamp).toLocaleTimeString()}`);
    }
  }
}

// processTickerUpdates('AAPL');

            

              
                Copy
              
            
          

முக்கிய குறிப்பு: .drop() தேவையற்ற ஆரம்ப கூறுகளை நிராகரிப்பதன் மூலம் ஸ்ட்ரீம்களை சுத்தம் செய்ய உதவுகிறது, செயலாக்கம் முக்கிய தரவில் கவனம் செலுத்துவதை உறுதி செய்கிறது.

5. .reduce(): ஸ்ட்ரீம் தரவைத் திரட்டுதல்

.reduce() ஹெல்பர் முழு ஒத்திசைவற்ற ஸ்ட்ரீமையும் ஒரே மதிப்பாகத் திரட்டுவதற்கான ஒரு சக்திவாய்ந்த கருவியாகும். இது ஒரு கால்பேக் செயல்பாடு (ரிட்யூசர்) மற்றும் ஒரு விருப்பத்தேர்வு ஆரம்ப மதிப்பைப் பெறுகிறது. ஒவ்வொரு உருப்படிக்கும் ரிட்யூசர் அழைக்கப்பட்டு, காலப்போக்கில் ஒரு முடிவைக் குவிக்கும்.

பயன்பாட்டு எடுத்துக்காட்டு (உலகளாவிய வானிலை தரவுத் திரட்டல்):

பல்வேறு கண்டங்களில் உள்ள வானிலை நிலையங்களிலிருந்து வெப்பநிலை அளவீடுகளை சேகரிப்பதை கற்பனை செய்து பாருங்கள். ஸ்ட்ரீமில் உள்ள அனைத்து அளவீடுகளுக்கும் சராசரி வெப்பநிலையைக் கணக்கிட நீங்கள் .reduce() ஐப் பயன்படுத்தலாம்.

            async function* getWeatherReadings(region) {
  // Simulate fetching temperature readings asynchronously for a region
  const readings = [
    { region: 'Europe', temp: 15 },
    { region: 'Asia', temp: 25 },
    { region: 'North America', temp: 18 },
    { region: 'Europe', temp: 16 },
    { region: 'Africa', temp: 30 }
  ];
  for (const reading of readings) {
    if (reading.region === region) {
      await new Promise(resolve => setTimeout(resolve, 20));
      yield reading;
    }
  }
}

async function calculateAverageTemperature(regions) {
  let allReadings = [];
  for (const region of regions) {
    const regionReadings = getWeatherReadings(region);
    // Collect readings from each region's stream
    for await (const reading of regionReadings) {
      allReadings.push(reading);
    }
  }

  // Use reduce to calculate the average temperature across all collected readings
  const totalTemperature = allReadings.reduce((sum, reading) => sum + reading.temp, 0);
  const averageTemperature = allReadings.length > 0 ? totalTemperature / allReadings.length : 0;

  console.log(`
--- Average temperature across ${regions.join(', ')}: ${averageTemperature.toFixed(1)}°C ---`);
}

// calculateAverageTemperature(['Europe', 'Asia', 'North America']);

            

              
                Copy
              
            
          

முக்கிய குறிப்பு: .reduce() ஒரு தரவு ஸ்ட்ரீமை ஒரே ஒட்டுமொத்த முடிவாக மாற்றுகிறது, இது திரட்டல்கள் மற்றும் சுருக்கங்களுக்கு அவசியம்.

6. .toArray(): முழு ஸ்ட்ரீமையும் ஒரு வரிசையாக மாற்றுதல்

.map() அல்லது .filter() போன்ற மாற்றும் ஹெல்பர்களைப் போல கண்டிப்பாக இல்லாவிட்டாலும், .toArray() ஒரு முழு அசிங்க் இட்டரேட்டரையும் பயன்படுத்தி, அதன் அனைத்து வழங்கப்பட்ட மதிப்புகளையும் ஒரு நிலையான ஜாவாஸ்கிரிப்ட் வரிசையில் சேகரிக்க ஒரு முக்கியமான பயன்பாடாகும். தரவு முழுமையாக ஸ்ட்ரீம் செய்யப்பட்ட பிறகு வரிசை-குறிப்பிட்ட செயல்பாடுகளைச் செய்ய வேண்டியிருக்கும் போது இது பயனுள்ளதாக இருக்கும்.

பயன்பாட்டு எடுத்துக்காட்டு (தொகுப்பு தரவை செயலாக்குதல்):

பக்கப்படுத்தப்பட்ட API-இலிருந்து பயனர் பதிவுகளின் பட்டியலைப் பெறுகிறீர்கள் என்றால், ஒரு அறிக்கை உருவாக்குதல் அல்லது தரவுத்தள உள்ளீடுகளைப் புதுப்பித்தல் போன்ற ஒரு மொத்த செயல்பாட்டைச் செய்வதற்கு முன்பு, அனைத்து பக்கங்களிலிருந்தும் அனைத்து பதிவுகளையும் சேகரிக்க முதலில் .toArray() ஐப் பயன்படுத்தலாம்.

            async function* getUserBatch(page) {
  // Simulate fetching a batch of users from a paginated API
  const allUsers = [
    { id: 1, name: 'Alice', country: 'USA' },
    { id: 2, name: 'Bob', country: 'Canada' },
    { id: 3, name: 'Charlie', country: 'UK' },
    { id: 4, name: 'David', country: 'Australia' }
  ];
  const startIndex = page * 2;
  const endIndex = startIndex + 2;
  for (let i = startIndex; i < endIndex && i < allUsers.length; i++) {
    await new Promise(resolve => setTimeout(resolve, 30));
    yield allUsers[i];
  }
}

async function getAllUsersFromPages() {
  let currentPage = 0;
  let hasMorePages = true;
  let allUsersArray = [];

  while (hasMorePages) {
    const userStreamForPage = getUserBatch(currentPage);
    const usersFromPage = await userStreamForPage.toArray(); // Collect all from current page

    if (usersFromPage.length === 0) {
      hasMorePages = false;
    } else {
      allUsersArray = allUsersArray.concat(usersFromPage);
      currentPage++;
    }
  }

  console.log(`
--- All users collected from pagination ---`);
  console.log(`Total users fetched: ${allUsersArray.length}`);
  allUsersArray.forEach(user => console.log(`- ${user.name} (${user.country})`));
}

// getAllUsersFromPages();

            

              
                Copy
              
            
          

முக்கிய குறிப்பு: ஒத்திசைவற்ற மீட்டெடுப்புக்குப் பிறகு முழுமையான தரவுத்தொகுப்புடன் நீங்கள் வேலை செய்ய வேண்டியிருக்கும் போது .toArray() இன்றியமையாதது, இது பழக்கமான வரிசை முறைகளுடன் பிந்தைய செயலாக்கத்தை செயல்படுத்துகிறது.

7. .concat(): பல ஸ்ட்ரீம்களை இணைத்தல்

.concat() ஹெல்பர் பல அசிங்க் இட்டரேட்டர்களை ஒரே, வரிசைமுறை அசிங்க் இட்டரேட்டராக இணைக்க உங்களை அனுமதிக்கிறது. இது முதல் இட்டரேட்டர் முடியும் வரை அதன் மூலம் சுழன்று, பின்னர் இரண்டாவதுக்கு நகர்கிறது, மற்றும் பல.

பயன்பாட்டு எடுத்துக்காட்டு (தரவு மூலங்களை இணைத்தல்):

உங்களிடம் வெவ்வேறு API-கள் அல்லது தரவு மூலங்கள் ஒரே மாதிரியான தகவல்களை (எ.கா., வெவ்வேறு பிராந்திய தரவுத்தளங்களிலிருந்து வாடிக்கையாளர் தரவு) வழங்குவதாக வைத்துக்கொள்வோம். .concat() இந்த ஸ்ட்ரீம்களை தடையின்றி செயலாக்கத்திற்கான ஒரு ஒருங்கிணைந்த தரவுத்தொகுப்பாக இணைக்க உதவுகிறது.

            async function* streamSourceA() {
  yield { id: 1, name: 'A1', type: 'sourceA' };
  yield { id: 2, name: 'A2', type: 'sourceA' };
}

async function* streamSourceB() {
  yield { id: 3, name: 'B1', type: 'sourceB' };
  await new Promise(resolve => setTimeout(resolve, 50));
  yield { id: 4, name: 'B2', type: 'sourceB' };
}

async function* streamSourceC() {
  yield { id: 5, name: 'C1', type: 'sourceC' };
}

async function processConcatenatedStreams() {
  const streamA = streamSourceA();
  const streamB = streamSourceB();
  const streamC = streamSourceC();

  // Concatenate streams A, B, and C
  const combinedStream = streamA.concat(streamB, streamC);

  console.log(`
--- Processing concatenated streams ---`);
  for await (const item of combinedStream) {
    console.log(`Received from ${item.type}: ${item.name} (ID: ${item.id})`);
  }
}

// processConcatenatedStreams();

            

              
                Copy
              
            
          

முக்கிய குறிப்பு: .concat() வெவ்வேறு ஒத்திசைவற்ற மூலங்களிலிருந்து வரும் தரவை ஒரே, நிர்வகிக்கக்கூடிய ஸ்ட்ரீமாக ஒருங்கிணைப்பதை எளிதாக்குகிறது.

8. .join(): ஸ்ட்ரீம் கூறுகளிலிருந்து ஒரு சரத்தை உருவாக்குதல்

Array.prototype.join()-ஐப் போலவே, அசிங்க் இட்டரேட்டர்களுக்கான .join() ஹெல்பர் அனைத்து வழங்கப்பட்ட உருப்படிகளையும் ஒரு குறிப்பிட்ட பிரிப்பானைப் பயன்படுத்தி ஒரே சரமாக இணைக்கிறது. அறிக்கைகள் அல்லது பதிவு கோப்புகளை உருவாக்குவதற்கு இது மிகவும் பயனுள்ளதாக இருக்கும்.

பயன்பாட்டு எடுத்துக்காட்டு (பதிவு கோப்பு உருவாக்கம்):

ஒரு அசிங்க் ஸ்ட்ரீம் பதிவு உள்ளீடுகளிலிருந்து ஒரு வடிவமைக்கப்பட்ட பதிவு வெளியீட்டை உருவாக்கும்போது, இந்த உள்ளீடுகளை ஒரே சரமாக இணைக்க .join() ஐப் பயன்படுத்தலாம், அதை பின்னர் ஒரு கோப்பில் எழுதலாம் அல்லது காட்டலாம்.

            async function* getLogEntries() {
  await new Promise(resolve => setTimeout(resolve, 10));
  yield "[INFO] User logged in.";
  await new Promise(resolve => setTimeout(resolve, 10));
  yield "[WARN] Disk space low.";
  await new Promise(resolve => setTimeout(resolve, 10));
  yield "[ERROR] Database connection failed.";
}

async function generateLogString() {
  const logStream = getLogEntries();

  // Join log entries with a newline character
  const logFileContent = await logStream.join('\n');

  console.log(`
--- Generated Log Content ---`);
  console.log(logFileContent);
}

// generateLogString();

            

              
                Copy
              
            
          

முக்கிய குறிப்பு: .join() ஒத்திசைவற்ற வரிசைகளை திறமையாக வடிவமைக்கப்பட்ட சரம் வெளியீடுகளாக மாற்றுகிறது, உரை தரவு கலைப்பொருட்களின் உருவாக்கத்தை நெறிப்படுத்துகிறது.

சக்திவாய்ந்த பைப்லைன்களுக்கு சங்கிலித் தொடராக்குதல்

இந்த ஹெல்பர்களின் உண்மையான சக்தி சங்கிலித் தொடராக்குதல் மூலம் அவற்றின் இணைக்கும் தன்மையில் உள்ளது. பல ஹெல்பர்களை ஒன்றாக இணைப்பதன் மூலம் நீங்கள் சிக்கலான தரவு செயலாக்க பைப்லைன்களை உருவாக்கலாம். இந்த விளக்கமளிக்கும் பாணி சிக்கலான ஒத்திசைவற்ற செயல்பாடுகளை பாரம்பரிய கட்டளை அணுகுமுறைகளை விட மிகவும் படிக்கக்கூடியதாகவும் பராமரிக்கக்கூடியதாகவும் ஆக்குகிறது.

எடுத்துக்காட்டு: பயனர் தரவைப் பெறுதல், வடிகட்டுதல் மற்றும் மாற்றுதல்

ஒரு உலகளாவிய API-இலிருந்து பயனர் தரவைப் பெறுதல், குறிப்பிட்ட பிராந்தியங்களில் உள்ள பயனர்களை வடிகட்டுதல், பின்னர் அவர்களின் பெயர்களையும் மின்னஞ்சல்களையும் ஒரு குறிப்பிட்ட வடிவத்திற்கு மாற்றுவதை கற்பனை செய்வோம்.

            async function* fetchGlobalUserData() {
  // Simulate fetching data from multiple sources, yielding user objects
  const users = [
    { id: 1, name: 'Alice Smith', country: 'USA', email: 'alice.s@example.com' },
    { id: 2, name: 'Bob Johnson', country: 'Canada', email: 'bob.j@example.com' },
    { id: 3, name: 'Chiyo Tanaka', country: 'Japan', email: 'chiyo.t@example.com' },
    { id: 4, name: 'David Lee', country: 'South Korea', email: 'david.l@example.com' },
    { id: 5, name: 'Eva Müller', country: 'Germany', email: 'eva.m@example.com' },
    { id: 6, name: 'Kenji Sato', country: 'Japan', email: 'kenji.s@example.com' }
  ];
  for (const user of users) {
    await new Promise(resolve => setTimeout(resolve, 15));
    yield user;
  }
}

async function processFilteredUsers(targetCountries) {
  const userDataStream = fetchGlobalUserData();

  const processedStream = userDataStream
    .filter(user => targetCountries.includes(user.country))
    .map(user => ({
      fullName: user.name.toUpperCase(),
      contactEmail: user.email.toLowerCase()
    }))
    .take(3); // Get up to 3 transformed users from the filtered list

  console.log(`
--- Processing up to 3 users from: ${targetCountries.join(', ')} ---`);
  for await (const processedUser of processedStream) {
    console.log(`Name: ${processedUser.fullName}, Email: ${processedUser.contactEmail}`);
  }
}

// processFilteredUsers(['Japan', 'Germany']);

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டு, சிக்கலான, பல-படி ஒத்திசைவற்ற தரவு செயல்பாடுகளைச் செய்ய .filter(), .map(), மற்றும் .take() ஆகியவற்றை எப்படி நேர்த்தியாக சங்கிலித் தொடராக்கலாம் என்பதைக் காட்டுகிறது.

உலகளாவிய பரிசீலனைகள் மற்றும் சிறந்த நடைமுறைகள்

ஒரு உலகளாவிய சூழலில் ஒத்திசைவற்ற இட்டரேட்டர்கள் மற்றும் அவற்றின் ஹெல்பர்களுடன் பணிபுரியும்போது, பல காரணிகள் முக்கியமானவை:

• சர்வதேசமயமாக்கல் (i18n) & உள்ளூர்மயமாக்கல் (l10n): தரவை, குறிப்பாக சரங்கள் அல்லது எண் மதிப்புகளை (விலைகள் அல்லது தேதிகள் போன்றவை) மாற்றும்போது, உங்கள் மேப்பிங் மற்றும் வடிகட்டுதல் தர்க்கம் வெவ்வேறு இடங்களை உள்ளடக்கியிருப்பதை உறுதிசெய்யுங்கள். உதாரணமாக, நாணய வடிவமைப்பு, தேதி பாகுபடுத்துதல் மற்றும் எண் பிரிப்பான்கள் நாடுகளுக்கிடையே கணிசமாக வேறுபடுகின்றன. உங்கள் மாற்றும் செயல்பாடுகள் i18n-ஐ மனதில் கொண்டு வடிவமைக்கப்பட வேண்டும், வலுவான சர்வதேச வடிவமைப்பிற்காக நூலகங்களைப் பயன்படுத்தலாம்.
• பிழை கையாளுதல்: ஒத்திசைவற்ற செயல்பாடுகள் பிழைகளுக்கு (நெட்வொர்க் சிக்கல்கள், தவறான தரவு) ஆளாகின்றன. ஒவ்வொரு ஹெல்பர் முறையும் ஒரு வலுவான பிழை-கையாளுதல் உத்திக்குள் பயன்படுத்தப்பட வேண்டும். for await...of வளையத்தைச் சுற்றி try...catch தொகுதிகளைப் பயன்படுத்துவது அவசியம். சில ஹெல்பர்கள் தங்கள் கால்பேக் செயல்பாடுகளுக்குள் பிழைகளைக் கையாள வழிகளையும் வழங்கலாம் (எ.கா., ஒரு இயல்புநிலை மதிப்பை அல்லது ஒரு குறிப்பிட்ட பிழைப் பொருளைத் திருப்புதல்).
• செயல்திறன் மற்றும் வள மேலாண்மை: ஹெல்பர்கள் குறியீட்டை எளிதாக்கினாலும், வள நுகர்வு குறித்து கவனமாக இருங்கள். .toArray() போன்ற செயல்பாடுகள் பெரிய தரவுத்தொகுப்புகளை முழுவதுமாக நினைவகத்தில் ஏற்றலாம், இது மிகப் பெரிய ஸ்ட்ரீம்களுக்கு சிக்கலாக இருக்கலாம். இடைநிலை மாற்றங்களைப் பயன்படுத்துவதையும் தேவையற்ற இடைநிலை வரிசைகளைத் தவிர்ப்பதையும் கருத்தில் கொள்ளுங்கள். முடிவில்லாத ஸ்ட்ரீம்களுக்கு, .take() போன்ற ஹெல்பர்கள் வள தீர்வைக் தடுக்க முக்கியமானவை.
• கவனிக்கத்தக்க தன்மை: சிக்கலான பைப்லைன்களுக்கு, தரவு ஓட்டத்தைக் கண்காணிப்பதும் இடையூறுகளை அடையாளம் காண்பதும் சவாலாக இருக்கலாம். ஒவ்வொரு கட்டத்திலும் என்ன தரவு செயலாக்கப்படுகிறது என்பதைப் புரிந்துகொள்ள உங்கள் .map() அல்லது .filter() கால்பேக்குகளுக்குள் (மேம்பாட்டின் போது) பதிவிடுதலைச் சேர்ப்பதைக் கருத்தில் கொள்ளுங்கள்.
• பொருந்தக்கூடிய தன்மை: அசிங்க் இட்டரேட்டர் ஹெல்பர்ஸ் ECMAScript 2023-இன் ஒரு பகுதியாக இருந்தாலும், உங்கள் இலக்கு சூழல்கள் (உலாவிகள், Node.js பதிப்புகள்) இந்த அம்சங்களை ஆதரிக்கின்றனவா என்பதை உறுதிப்படுத்தவும். பழைய சூழல்களுக்கு பாலிஃபில்கள் தேவைப்படலாம்.
• செயல்பாட்டு கலவை: செயல்பாட்டு நிரலாக்க முன்னுதாரணத்தைத் தழுவுங்கள். இந்த ஹெல்பர்கள் சிக்கலான நடத்தைகளை உருவாக்க சிறிய, தூய செயல்பாடுகளை இயற்றுவதை ஊக்குவிக்கின்றன. இது குறியீட்டை சோதிக்கக்கூடியதாகவும், மீண்டும் பயன்படுத்தக்கூடியதாகவும், வெவ்வேறு கலாச்சாரங்கள் மற்றும் நிரலாக்க பின்னணிகளில் புரிந்துகொள்ள எளிதாகவும் ஆக்குகிறது.

ஜாவாஸ்கிரிப்ட்டில் அசிங்க் ஸ்ட்ரீம் செயலாக்கத்தின் எதிர்காலம்

அசிங்க் இட்டரேட்டர் ஹெல்பர்ஸ் ஜாவாஸ்கிரிப்ட்டில் மேலும் தரப்படுத்தப்பட்ட மற்றும் சக்திவாய்ந்த ஒத்திசைவற்ற நிரலாக்க வடிவங்களை நோக்கிய ஒரு குறிப்பிடத்தக்க படியைக் குறிக்கிறது. அவை கட்டளை மற்றும் செயல்பாட்டு அணுகுமுறைகளுக்கு இடையிலான இடைவெளியைக் குறைக்கின்றன, ஒத்திசைவற்ற தரவு ஸ்ட்ரீம்களை நிர்வகிக்க ஒரு விளக்கமளிக்கும் மற்றும் மிகவும் படிக்கக்கூடிய வழியை வழங்குகின்றன.

உலகளவில் டெவலப்பர்கள் இந்த வடிவங்களை ஏற்றுக்கொள்வதால், இந்த அடித்தளத்தில் கட்டமைக்கப்பட்ட மேலும் மேம்பட்ட நூலகங்கள் மற்றும் கட்டமைப்புகளை நாம் எதிர்பார்க்கலாம். இத்தகைய தெளிவுடன் சிக்கலான தரவு மாற்றங்களை இயற்றும் திறன், மாறுபட்ட சர்வதேச பயனர் தளத்திற்கு சேவை செய்யும் அளவிடக்கூடிய, திறமையான மற்றும் பராமரிக்கக்கூடிய பயன்பாடுகளை உருவாக்குவதற்கு விலைமதிப்பற்றது.

முடிவுரை

ஜாவாஸ்கிரிப்ட்டின் அசிங்க் இட்டரேட்டர் ஹெல்பர்ஸ் ஒத்திசைவற்ற தரவு ஸ்ட்ரீம்களுடன் பணிபுரியும் எவருக்கும் ஒரு கேம்-சேஞ்சர் ஆகும். .map() மற்றும் .filter() உடன் எளிய மாற்றங்களிலிருந்து, .reduce() உடன் சிக்கலான திரட்டல்கள் மற்றும் .concat() உடன் ஸ்ட்ரீம் இணைத்தல் வரை, இந்த கருவிகள் டெவலப்பர்களுக்கு சுத்தமான, திறமையான மற்றும் மேலும் வலுவான குறியீட்டை எழுத அதிகாரம் அளிக்கின்றன.

இந்த ஹெல்பர்களைப் புரிந்துகொண்டு பயன்படுத்துவதன் மூலம், உலகெங்கிலும் உள்ள டெவலப்பர்கள் ஒத்திசைவற்ற தரவைச் செயலாக்கி மாற்றுவதற்கான தங்கள் திறனை மேம்படுத்தலாம், இது சிறந்த பயன்பாட்டு செயல்திறன் மற்றும் மேலும் உற்பத்தித்திறன் மிக்க மேம்பாட்டு அனுபவத்திற்கு வழிவகுக்கும். ஜாவாஸ்கிரிப்ட்டின் ஒத்திசைவற்ற திறன்களுக்கான இந்த சக்திவாய்ந்த சேர்த்தல்களைத் தழுவி, உங்கள் ஸ்ட்ரீம் செயலாக்க முயற்சிகளில் புதிய செயல்திறன் நிலைகளைத் திறந்திடுங்கள்.